/**
 * 此包代表社团管理系统的主功能模块，包含系统的核心类和逻辑。
 */
package demo6;

import java.util.Date;
import java.util.Scanner;

/**
 * author : 李硕
 * version : 1.0
 * 2307124008
 * ClubManagementSystem 类是社团管理系统的入口类，通过控制台与用户进行交互，
 * 实现对社团、分类、新闻、活动和报名等信息的管理操作。用户可以根据菜单提示，
 * 选择不同的操作对相关信息进行添加、修改、查询和删除等操作。
 *
 */
public class ClubManagementSystem {
    /**
     * 程序的入口方法，启动社团管理系统并进入主循环，持续等待用户输入操作指令。
     *
     * @param args 命令行参数，在本程序中未使用。
     */
    public static void main(String[] args) {
        // 创建 Scanner 对象，用于从控制台读取用户输入的信息
        Scanner scanner = new Scanner(System.in);

        // 初始化各个管理对象，初始值均为 null，后续根据用户操作进行实例化
        // 社团对象，用于管理社团的添加、修改、查询和解散等操作
        demo6.Club club = null;
        // 分类对象，用于管理分类的添加、修改、删除和查询等操作
        Category category = null;
        // 新闻对象，用于管理新闻的添加、修改、查询和发布等操作
        demo6.News news = null;
        // 活动对象，用于管理活动的添加、修改、查询和结束等操作
        demo6.Activity activity = null;
        // 报名对象，用于管理报名的添加、查询和结束等操作
        demo6.Registration registration = null;

        // 进入无限循环，持续显示主菜单并等待用户输入，直到用户选择退出系统
        while (true) {
            // 输出主菜单选项，提示用户可以选择的操作
            System.out.println("\n请选择操作：");
            System.out.println("1. 社团操作");
            System.out.println("2. 分类操作");
            System.out.println("3. 新闻操作");
            System.out.println("4. 活动操作");
            System.out.println("5. 报名操作");
            System.out.println("6. 退出");

            // 读取用户输入的主菜单选项
            int choice = scanner.nextInt();
            // 消耗掉 nextInt() 方法遗留的换行符，避免影响后续 nextLine() 方法的使用
            scanner.nextLine();

            // 根据用户输入的主菜单选项，使用 switch 语句进行分支处理
            switch (choice) {
                case 1:
                    // 社团操作分支
                    // 输出社团操作子菜单
                    System.out.println("请选择社团操作：");
                    System.out.println("1. 添加社团");
                    System.out.println("2. 修改社团");
                    System.out.println("3. 查询社团");
                    System.out.println("4. 解散社团");

                    // 读取用户输入的社团操作子菜单选项
                    int clubChoice = scanner.nextInt();
                    // 消耗掉 nextInt() 方法遗留的换行符
                    scanner.nextLine();

                    // 根据用户输入的社团操作子菜单选项，使用 switch 语句进行分支处理
                    switch (clubChoice) {
                        case 1:
                            // 添加社团操作
                            // 提示用户输入社团的各项信息
                            System.out.println("请输入社团编号:");
                            int clubId = scanner.nextInt();
                            // 消耗掉 nextInt() 方法遗留的换行符
                            scanner.nextLine();
                            System.out.println("请输入社团说明:");
                            String clubDescription = scanner.nextLine();
                            System.out.println("请输入社团名称:");
                            String clubName = scanner.nextLine();
                            System.out.println("请输入社团人数:");
                            int memberCount = scanner.nextInt();
                            // 消耗掉 nextInt() 方法遗留的换行符
                            scanner.nextLine();
                            System.out.println("请输入社长姓名:");
                            String presidentName = scanner.nextLine();
                            System.out.println("请输入社团指导老师:");
                            String advisorName = scanner.nextLine();

                            // 调用 Club 类的静态方法 addClub 创建新的社团对象
                            club = demo6.Club.addClub(clubId, clubDescription, clubName, memberCount, presidentName, advisorName);
                            System.out.println("社团添加成功");
                            break;
                        case 2:
                            // 修改社团操作
                            // 检查社团对象是否已经创建，如果未创建则提示用户先添加社团
                            if (club != null) {
                                // 提示用户输入新的社团信息
                                System.out.println("请输入新的社团说明:");
                                String newClubDescription = scanner.nextLine();
                                System.out.println("请输入新的社团名称:");
                                String newClubName = scanner.nextLine();
                                System.out.println("请输入新的社团人数:");
                                int newMemberCount = scanner.nextInt();
                                // 消耗掉 nextInt() 方法遗留的换行符
                                scanner.nextLine();
                                System.out.println("请输入新的社长姓名:");
                                String newPresidentName = scanner.nextLine();
                                System.out.println("请输入新的社团指导老师:");
                                String newAdvisorName = scanner.nextLine();

                                // 调用社团对象的 modifyClub 方法更新社团信息
                                club.modifyClub(newClubDescription, newClubName, newMemberCount, newPresidentName, newAdvisorName);
                                System.out.println("社团修改成功");
                            } else {
                                System.out.println("请先添加社团");
                            }
                            break;
                        case 3:
                            // 查询社团操作
                            // 检查社团对象是否已经创建，如果已创建则调用查询方法显示社团信息
                            if (club != null) {
                                club.queryClub();
                            } else {
                                System.out.println("请先添加社团");
                            }
                            break;
                        case 4:
                            // 解散社团操作
                            // 检查社团对象是否已经创建，如果已创建则调用解散方法并将对象置为 null
                            if (club != null) {
                                club.dissolveClub();
                                club = null;
                            } else {
                                System.out.println("请先添加社团");
                            }
                            break;
                        default:
                            // 处理用户输入的无效选项
                            System.out.println("无效的选择");
                    }
                    break;
                case 2:
                    // 分类操作分支
                    // 输出分类操作子菜单
                    System.out.println("请选择分类操作：");
                    System.out.println("1. 添加分类");
                    System.out.println("2. 修改分类");
                    System.out.println("3. 删除分类");
                    System.out.println("4. 查询分类");

                    // 读取用户输入的分类操作子菜单选项
                    int categoryChoice = scanner.nextInt();
                    // 消耗掉 nextInt() 方法遗留的换行符
                    scanner.nextLine();

                    // 根据用户输入的分类操作子菜单选项，使用 switch 语句进行分支处理
                    switch (categoryChoice) {
                        case 1:
                            // 添加分类操作
                            // 提示用户输入分类的各项信息
                            System.out.println("请输入分类编号:");
                            int categoryId = scanner.nextInt();
                            // 消耗掉 nextInt() 方法遗留的换行符
                            scanner.nextLine();
                            System.out.println("请输入分类名称:");
                            String categoryName = scanner.nextLine();
                            System.out.println("请输入分类说明:");
                            String categoryDescription = scanner.nextLine();
                            System.out.println("请输入是否停用 (true/false):");
                            boolean isDisabled = scanner.nextBoolean();
                            // 消耗掉 nextBoolean() 方法遗留的换行符
                            scanner.nextLine();

                            // 调用 Category 类的静态方法 addCategory 创建新的分类对象
                            category = demo6.Category.addCategory(categoryId, categoryName, categoryDescription, isDisabled);
                            System.out.println("分类添加成功");
                            break;
                        case 2:
                            // 修改分类操作
                            // 检查分类对象是否已经创建，如果未创建则提示用户先添加分类
                            if (category != null) {
                                // 提示用户输入新的分类信息
                                System.out.println("请输入新的分类名称:");
                                String newCategoryName = scanner.nextLine();
                                System.out.println("请输入新的分类说明:");
                                String newCategoryDescription = scanner.nextLine();
                                System.out.println("请输入新的是否停用 (true/false):");
                                boolean newIsDisabled = scanner.nextBoolean();
                                // 消耗掉 nextBoolean() 方法遗留的换行符
                                scanner.nextLine();

                                // 调用分类对象的 modifyCategory 方法更新分类信息
                                category.modifyCategory(newCategoryName, newCategoryDescription, newIsDisabled);
                                System.out.println("分类修改成功");
                            } else {
                                System.out.println("请先添加分类");
                            }
                            break;
                        case 3:
                            // 删除分类操作
                            // 检查分类对象是否已经创建，如果已创建则调用删除方法并将对象置为 null
                            if (category != null) {
                                category.deleteCategory();
                                category = null;
                            } else {
                                System.out.println("请先添加分类");
                            }
                            break;
                        case 4:
                            // 查询分类操作
                            // 检查分类对象是否已经创建，如果已创建则调用查询方法显示分类信息
                            if (category != null) {
                                category.queryCategory();
                            } else {
                                System.out.println("请先添加分类");
                            }
                            break;
                        default:
                            // 处理用户输入的无效选项
                            System.out.println("无效的选择");
                    }
                    break;
                case 3:
                    // 新闻操作分支
                    // 输出新闻操作子菜单
                    System.out.println("请选择新闻操作：");
                    System.out.println("1. 添加新闻");
                    System.out.println("2. 修改新闻");
                    System.out.println("3. 查询新闻");
                    System.out.println("4. 发布新闻");

                    // 读取用户输入的新闻操作子菜单选项
                    int newsChoice = scanner.nextInt();
                    // 消耗掉 nextInt() 方法遗留的换行符
                    scanner.nextLine();

                    // 根据用户输入的新闻操作子菜单选项，使用 switch 语句进行分支处理
                    switch (newsChoice) {
                        case 1:
                            // 添加新闻操作
                            // 检查分类对象是否已经创建，因为新闻需要关联分类
                            if (category != null) {
                                // 提示用户输入新闻的各项信息
                                System.out.println("请输入新闻编号:");
                                int newsId = scanner.nextInt();
                                // 消耗掉 nextInt() 方法遗留的换行符
                                scanner.nextLine();
                                System.out.println("请输入新闻名称:");
                                String newsName = scanner.nextLine();
                                System.out.println("请输入新闻内容:");
                                String newsContent = scanner.nextLine();
                                System.out.println("请输入新闻创建人:");
                                String newsCreator = scanner.nextLine();

                                // 调用 News 类的静态方法 addNews 创建新的新闻对象
                                news = demo6.News.addNews(newsId, newsName, category, newsContent, newsCreator, new Date());
                                System.out.println("新闻添加成功");
                            } else {
                                System.out.println("请先添加分类");
                            }
                            break;
                        case 2:
                            // 修改新闻操作
                            // 检查新闻对象和分类对象是否都已经创建
                            if (news != null && category != null) {
                                // 提示用户输入新的新闻信息
                                System.out.println("请输入新的新闻名称:");
                                String newNewsName = scanner.nextLine();
                                System.out.println("请输入新的新闻内容:");
                                String newNewsContent = scanner.nextLine();
                                System.out.println("请输入新的新闻创建人:");
                                String newNewsCreator = scanner.nextLine();

                                // 调用新闻对象的 modifyNews 方法更新新闻信息
                                news.modifyNews(newNewsName, category, newNewsContent, newNewsCreator, new Date());
                                System.out.println("新闻修改成功");
                            } else {
                                System.out.println("请先添加新闻和分类");
                            }
                            break;
                        case 3:
                            // 查询新闻操作
                            // 检查新闻对象是否已经创建，如果已创建则调用查询方法显示新闻信息
                            if (news != null) {
                                news.queryNews();
                            } else {
                                System.out.println("请先添加新闻");
                            }
                            break;
                        case 4:
                            // 发布新闻操作
                            // 检查新闻对象是否已经创建，如果已创建则调用发布方法
                            if (news != null) {
                                news.publishNews();
                            } else {
                                System.out.println("请先添加新闻");
                            }
                            break;
                        default:
                            // 处理用户输入的无效选项
                            System.out.println("无效的选择");
                    }
                    break;
                case 4:
                    // 活动操作分支
                    // 输出活动操作子菜单
                    System.out.println("请选择活动操作：");
                    System.out.println("1. 添加活动");
                    System.out.println("2. 修改活动");
                    System.out.println("3. 查询活动");
                    System.out.println("4. 结束活动");

                    // 读取用户输入的活动操作子菜单选项
                    int activityChoice = scanner.nextInt();
                    // 消耗掉 nextInt() 方法遗留的换行符
                    scanner.nextLine();

                    // 根据用户输入的活动操作子菜单选项，使用 switch 语句进行分支处理
                    switch (activityChoice) {
                        case 1:
                            // 添加活动操作
                            // 提示用户输入活动的各项信息
                            System.out.println("请输入活动编号:");
                            int activityId = scanner.nextInt();
                            // 消耗掉 nextInt() 方法遗留的换行符
                            scanner.nextLine();
                            System.out.println("请输入活动内容:");
                            String activityContent = scanner.nextLine();
                            System.out.println("请输入活动名称:");
                            String activityName = scanner.nextLine();
                            System.out.println("请输入活动组织者:");
                            String activityOrganizer = scanner.nextLine();

                            // 调用 Activity 类的静态方法 addActivity 创建新的活动对象
                            activity = demo6.Activity.addActivity(activityId, activityContent, activityName, activityOrganizer, new Date());
                            System.out.println("活动添加成功");
                            break;
                        case 2:
                            // 修改活动操作
                            // 检查活动对象是否已经创建，如果未创建则提示用户先添加活动
                            if (activity != null) {
                                // 提示用户输入新的活动信息
                                System.out.println("请输入新的活动内容:");
                                String newActivityContent = scanner.nextLine();
                                System.out.println("请输入新的活动名称:");
                                String newActivityName = scanner.nextLine();
                                System.out.println("请输入新的活动组织者:");
                                String newActivityOrganizer = scanner.nextLine();

                                // 调用活动对象的 modifyActivity 方法更新活动信息
                                activity.modifyActivity(newActivityContent, newActivityName, newActivityOrganizer, new Date());
                                System.out.println("活动修改成功");
                            } else {
                                System.out.println("请先添加活动");
                            }
                            break;
                        case 3:
                            // 查询活动操作
                            // 检查活动对象是否已经创建，如果已创建则调用查询方法显示活动信息
                            if (activity != null) {
                                activity.queryActivity();
                            } else {
                                System.out.println("请先添加活动");
                            }
                            break;
                        case 4:
                            // 结束活动操作
                            // 检查活动对象是否已经创建，如果已创建则调用结束方法
                            if (activity != null) {
                                activity.endActivity();
                            } else {
                                System.out.println("请先添加活动");
                            }
                            break;
                        default:
                            // 处理用户输入的无效选项
                            System.out.println("无效的选择");
                    }
                    break;
                case 5:
                    // 报名操作分支
                    // 输出报名操作子菜单
                    System.out.println("请选择报名操作：");
                    System.out.println("1. 添加报名");
                    System.out.println("2. 查询报名");
                    System.out.println("3. 结束报名");

                    // 读取用户输入的报名操作子菜单选项
                    int registrationChoice = scanner.nextInt();
                    // 消耗掉 nextInt() 方法遗留的换行符
                    scanner.nextLine();

                    // 根据用户输入的报名操作子菜单选项，使用 switch 语句进行分支处理
                    switch (registrationChoice) {
                        case 1:
                            // 添加报名操作
                            // 检查活动对象是否已经创建，因为报名需要关联活动
                            if (activity != null) {
                                // 提示用户输入报名的各项信息
                                System.out.println("请输入报名编号:");
                                int registrationId = scanner.nextInt();
                                int activityId = activity.getActivityId();
                                // 消耗掉 nextInt() 方法遗留的换行符
                                scanner.nextLine();
                                System.out.println("请输入报名人姓名:");
                                String registrantName = scanner.nextLine();
                                System.out.println("请输入报名人联系方式:");
                                String registrantContact = scanner.nextLine();

                                // 调用 Registration 类的静态方法 addRegistration 创建新的报名对象
                                registration = demo6.Registration.addRegistration(registrationId, activityId, registrantName, registrantContact, new Date(), false);
                                System.out.println("报名添加成功");
                            } else {
                                System.out.println("请先添加活动");
                            }
                            break;
                        case 2:
                            // 查询报名操作
                            // 检查报名对象是否已经创建，如果已创建则调用查询方法显示报名信息
                            if (registration != null) {
                                registration.queryRegistration();
                            } else {
                                System.out.println("请先添加报名");
                            }
                            break;
                        case 3:
                            // 结束报名操作
                            // 检查报名对象是否已经创建，如果已创建则调用结束方法
                            if (registration != null) {
                                registration.endRegistration();
                            } else {
                                System.out.println("请先添加报名");
                            }
                            break;
                        default:
                            // 处理用户输入的无效选项
                            System.out.println("无效的选择");
                    }
                    break;
                case 6:
                    // 退出系统操作
                    // 输出退出信息
                    System.out.println("退出系统");
                    // 关闭 Scanner 对象，释放资源
                    scanner.close();
                    // 终止 main 方法，退出程序
                    return;
                default:
                    // 处理用户输入的无效主菜单选项
                    System.out.println("无效的选择，请重新输入");
            }
        }
    }
}